Trivial doc fixups

build: Make sure GTK compiles without Vulkan headers installed

Previously, code would work fine with --disable-vulkan if the Vulkan
headers were installed - code would happily just use them as they're
installed in /usr/include.

Forgotten file

Rename GDK_WINDOWING_VULKAN

The WINDOWING defines are only for GDK backends, really.
Define GDK_RENDERING_VULKAN instead.

Only include vulkan.h if we have it

Fix the configure check for Vulkan

GDK_WINDOWING_VULKAN was getting defined regardless of the tests.

vulkan: Implement texture caching

And with this change, the GPU looks bored again.

vulkan: Don't create more than one render object

By creating unlimited render objects, we would never wait on the GPU.

This would mean that if the GPU was the bottleneck, we would fill its
queue with render commands faster than it could process them.

And because the nvidia binary driver and my code work surprisingly well
and bugfree, this lead to exhaustion of RAM. I had 50GB of swap
configured and my hard disk was quicker as swap storage than my GPU was
at processing the commands, so stuff still filled up.

At that point my computer became rather unresponsive and I decided to
reboot it, so I that could write this patch.

vulkan: Don't limit number of descriptor sets

If we need more than we have reserved as maximum, recreate the
descriptor pool with a higher maximum.

vulkan: Add more node operations

Add SURFACE and TEXTURE operations. This way, we actually render more
than one node every frame because not everything is a fallback node
anymore that gets composited with its children into a cairo surface.

vulkan: Push the correct matrix when drawing

Instead of pushing the root matrix, push the world matrix for the
current node. That way, the bounds we emit as vertices are actually
properly transformed.

vulkan: Enable alpha blending

We will need that once we actually composite stuff.

vulkan: Redo descriptor set handling

First, we collect all the info about descriptor sets into a hash table,
then we use its size to determine the amount of sets and allocate those
before we finally go ahead and use the hash table's contents to
initialize the descriptor sets.

And then we're ready to render.

vulkan: Move remaining structs to VulkanRender object

It now gets to maintain things.

vulkan: Create framebuffers from GskVulkanRender object

Also create them on-demand, as they need to be created per-image and
per-framebuffer, so we don't want to create loads of them.

vulkan: Turn swapchain image targets into GskVulkanImages

This gives us proper refcounting here, too. And there's no longer a
difference between the different types of images.

vulkan: Store width/height of GskVulkanImage

This is to enable lazy framebuffer creation later.

vulkan: Turn GskVulkanImage into a GObject

This way, we can do real refcounting on them.

vulkan: Hook up image upload mechanism to env variables

Instead of having to decie at compile-time, check if
GSK_RENDERING=staging-image was given, and if so, select the staging
image upload mode.

vulkan: Don't wait until graphics are done computing

We can let the GPU do its stuff without waiting. The GPU knows what it's
doing.

Which means we now get a lot of time to spend on doing CPU things (read:
we're way better in benchmarks).

The old behavior is safer, so we want to keep it around for debugging.
It can be reenabled with GSK_RENDERING_MODE=sync.

vulkan: Keep render objects around

That way we can reuse them. We only create a new one if the last render
operation hasn't finished executing.

vulkan: Move command pool and fence into render object

vulkan: Make the GskVulkanRender struct private

vulkan: Make the VulkanRender object allocated

That way, we can have multiple of those and keep them around for reuse.

vulkan: Also wait on the draw semaphore when present()ing

That way we have a synchronization primitive at the start and at the
end.

vulkan: Add GskVulkanRenderPass

And move the actual rendering code there.

A RenderPass is a collection of operations on the same target that
get executed one after another. It roughly targets VkRenderPass or
rather the subpasses of a VkRenderPass.

For now, only the infrastructure is there. No real stuff is happening.

vulkan: Add GskVulkanRender object

This is refactoring work.

GskVulkanRender is supposed to be the global object for a render
operation, ie GskVulkanRenderer.render() will create this object for
what it does.

The object will be split into stages that perform the operations
necessary to create a drawing.

vulkan: Make MVP matrix available to vertex shader

We use push constants for this.

vulkan: Upload image data directly

Instead of using a staging iamge, we require the final image to be
linearly allocated and have host-visible memory.

This improves performance quite a bit.

The old code is still there and can be enabled with a simple change
to a #define in gskvulkanimage.h

vulkan: Make GskVulkanRenderer work

We now create a Cairo renderer, render to an image surface and upload
and retnder it with Vulkan.

xim: Use the native parent window for the X connection

Don't try to gdk_window_get_xid() on the current window.

x11: Don't make random windows native

Instead, complain if somebody calls gdk_x11_window_get_xid() on a
non-native window.

We cannot make random windows native anymore because there's no GSK
renderer associated with them, so we cannot draw them.

gsk: Pass texture coordinates to Vulkan renderer

We just render the coordinates as color, we don't do anything with them
yet.

gsk: Loads of work on Vulkan backend

We can now upload vertices.

And we use this to draw a yellow background. Which is clearly superior
to not drawing anything.

Also, we have shaders now. If you modify them, you need glslc installed
so they can be recompiled into Spir-V bytecode.

configure: Improve Vulkan detection

1. Output Vulkan status in summary
2. Add missing "test" call
3. Check for glslc

The glslc check will be necessary later for the code that automatically
compiles the Vulkan glsl source to Spir-V.
Nothing happens if glslc is not available - unless you modify the glsl.

vulkan: acquire/present images when drawing

Another step towards the final goal of actually showing something.

gskvulkan: Create render pass and command pool

gskvulkanrenderer: Create imagevies and framebuffers

gsk: Add a vulkan debug category

vulkan: Expose the swapchain images in public API

gsk: Add skeleton for Vulkan renderer

The renderer itself obviously doesn't do anything.

vulkan: Register debug handler

We now hook Vulkan error reporting into glib's error reporting.

I'm not sure on the severity handling yet, but we can fix that as we go
along.

gdk: Add GDK_VULKAN env variable

Also add 2 flags:

GDK_VULKAN="disable" will disable Vulkan usage.

GDK_VULKAN="validate" will enable VK_LAYER_LUNARG_standard_validation.

x11: Call gdk_display_sync() when creating Vulkan surfaces

The Vulkan driver wants to operate on an X Window that it is sure does
exist.

vulkan: More work on GdkVulkanContext

Code has now arrived at creation of swapchains.

vulkan: Turn GdkVulkanContext into a GdkDrawContext

vulkan: Add more infrastructure

gdk_window_create_vulkan_context() now exists and will return a Vulkan
context for the given window. It even initializes the surface. But it
doesn't do anything useful yet.

vulkan: Initial support

Adds the gdk_display_ref_vulkan() and gdk_display_unref_vulkan()
functions which setup/tear down VUlkan support for the display.

Nothing is using those functions yet.

build: Add Vulkan detection code

Also define GDK_WINDOWING_VULKAN if Vulkan is enabled.

Update Italian translation
(cherry picked from commit 44fb5c9c704c39fad392ca45c6c2d74d6633a4e4)

mir: swap buffers on paint

widget: Remove unused adjust_* vfuncs

Expose them privately to gtksizerequest.c using normal functions
instead.

menu: Replace button-press-handler with gesture

toolbar: Replace button-press-event handler with gesture

linkbutton: Replace button-press-event handler with gesture

separatortoolitem: Remove button-event/motion-event handlers

These only exist for the window dragging which does not exist anymore
currently. It will be reintroduced later in a form that does not require
these handlers.

snapshot: Add annotations to parameters/return values

widget: Use gtk_widget_measure to measure widget sizes

widget: Remove _gtk_widget_supports_clip

widget: Remove gtk_widget_invalidate_style_context

wayland: Sync attributes also when drawing with GL

Probably syncing attributes shouldn't happen when drawing in the first
place, but what do I know about Wayland. ¯\_(ツ)_/¯

wayland: Uncomment erroneously commented out code

I read the code as if (use_gl) instead of if (!use_gl) and commented it
out in bddfd7bb41cebd9b4e8ea418ce4d8e1f11822e81. That broke drawing on
Wayland without OpenGL completely.

Whoops.

Now it's back.

GDK/Win32: Fix build after GDKGL refactoring

There were some parts that need some updates after the refactoring in
GDKGL, so that the code will continue to build and run.

For gdkwindow-win32.c, comment out the parts where we check for use_gl
(which was removed), since we are going to move all drawing to OpenGL,
but don't remove/disable the whole portion as that transition is not
complete at this point.

There a is new GDKGL function that checks for the damaged area of the back
buffer, but since the notion of "damage" is for *NIX (GLX/EGL for
Wayland/mir), meaning that there is no such extension for Windows in this
regard, so we can't support this on Windows as-is, at least for now.

https://bugzilla.gnome.org/show_bug.cgi?id=773299

Update POTFILES.in

build: add gir depends for GdkX11, GdkWin32, and Gsk on Gdk

https://bugzilla.gnome.org/show_bug.cgi?id=775651

mir: fix type warning

mir: fix build failures

mir: implement display monitor vfuncs

gdkgl: Add gdk_gl_context_get_damage()

This is a way to query the damaged area of the backbuffer.

The GL renderer uses this to compute the extents of that damage region
(computed via buffer age) and use them to minimize the area to redraw.

This changes the semantics of GL rendering to "When calling
gdk_window_begin_frame() with a GL context, the area by
gdk_gl_context_get_damage() needs to be redrawn and every other pixel of
the backbuffer is guaranteed to be correct.
After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer
must be correct.

We can always glXBufferSwap() now because of this.

inspector: Add support for displayin the render region

Now I just need a UI designer that makes this look nice...

glrenderer: Always redraw the whole screen

gdk: Make gdk_window_begin_draw_frame() take a draw context

... instead of a gl context.

This requires some refactoring in the way we mark the shared context as
drawing: We now call begin_frame/end_frame() on it and ignore the call
on the main context.
Unfortunately we need to do this check in all vfuncs, which sucks. But I
haven't found a better way.

gskrenderer: Add gsk_renderer_begin_draw_frame()

This way, we can hijack the begin/end draw process and do out own
processing before passing it on to GDK.

inspector: Pass the drawing context into the recorder

That way we can capture both the actual changes (clip region) and the
area that was redrawn (render region), which in OpenGL might not be
identical.

Nothing shows the render region yet though...

glrenderer: Always redraw the whole screen

gsk: Change GSK_USE_SOFTWARE env var to GSK_RENDERER

This way, we can use the variable as more than a boolean flag.

This will be useful for Vulkan or D3D renderers.

gdk: Turn GdkGLContext into a GdkDrawContext

gdk: Add GdkDrawContext

This will be the base class for GdkVulkanContext and GdkGLContext.

gdk: Redo GL drawing

Reenable GL drawing, but do it without Cairo.

Now, the context passed to gdk_window_begin_draw_frame() decides how
drawing is going to happen. If it is NULL, Cairo is used like before.

If a context is passed, Cairo may not be used for drawing and
gdk_drawing_context_get_cairo_context() is going to return NULL.
Instead, the GL renderer must draw to the GL backbuffer and
end_draw_frame() is then swapping that to the front.

The GskGLRenderer has lost the texture it used to render to and adapted
to render directly to the backbuffer instead.

The only thing missing is for GtkGLArea to gain back a performant way to
render. But it didn't have one since the introduction of GSK, this
patchset doesn't change anything about it.

The new rendering avoids two indirections (the GSK renderer's texture
and the GDK double buffering surface).
It improves icon count in the fishbowl demo by 30%.

glcontext: Make begin/end_draw() paired

This way, we can query the GL context's state via
gdk_gl_context_is_drawing().

Use this function to make GL contexts as attached and grant them access
to the front/backbuffer for rendering.

All of this is still unused because GL drawing is still disabled.

gdk: Large GL refactoring

No visible changes as GL rendering is disabled at the moment.

What was done:

1. Move window->invalidate_for_new_frame to glcontext->begin_frame
This moves the code to where it is used (the GLContext) and prepares it
for being called where it is used when actually beginning to draw the
frame.

2. Get rid of buffer-age usage
We want to let the application render directly to the backbuffer.
Because of that, we cannot make any assumptions about the contents the
application renders outside the clip area.
In particular GskGLRenderer renders random stuff there but not actual
contents.

3. Pass the actual GL context
Previously, we passed the shared context to end_frame, now we pass the
actual GL context that the application uses for rendering. This is so
that the vfuncs could prepare the actual contexts for rendering (they
don't currently).

4. Simplify the code
The previous code set up the final drawing method in begin_frame.
Instead, we now just ensure the clip area is something we can render
and decide on the actual method in end_frame.
This is both more robust (we can change the clip area in between if we
want to) and less code.

gsk: Allow 0 for gsk_gl_driver_begin_frame()

Special-case this situation to unset the current framebuffer and render
to the backbuffer again.

gdk: Don't recurse when processing updates

We don't need to send expose events for backwards compatibility anymore.

gdk: Remove all code that only existed because of use_gl

Now that we don't use GL anymore, this code is unnecessary.

gdk: Never draw with GL

This is a temporary switch-off of the GL dawing code that will make
things keep running. All GL related code (like the GSK renderer or
GtkGLArea will now fall back to software.

gskrenderer: Store the GL context

And use it to create the drawing context with it.

Note that this doesn't yet have any effect and is all infrastructure
preparation work.

API: Require passing a GLContext to begin_draw_frame()

This is in preparation for requiring explicit passing of GL contexts
when drawing.

window: Change behavior of gdk_window_begin_draw_frame()

(1) Require a native window
(2) Create the drawing context before calling begin_paint().

drawingcontext: Store the GL paint context

cssgadget: Compute relative to own allocation, not widget allocation

This would lead to clipped gadgets when the gadget allocation differed
from the widget allocation, like in GtkListBox.

wayland: destroy subsurfaces along with parents

Wayland subsurfaces can have other native window parents, but those need
to be destroyed along with the rest of the window hierarchy otherwise
an assert() is reached.

https://bugzilla.gnome.org/show_bug.cgi?id=774915

frame: Use gtk_widget_measure to measure child sizes

viewport: Use gtk_widget_measure to measure child sizes

and rewrite the adjustment handling in a orientation-agnostic way.

scrolledwindow: measure child widgets using gtk_widget_measure

revealer: Measure child widget size using gtk_widget_measure

headerbar: measure children using gtk_widget_measure

widget-factory: Use GtkButton:icon-name to construct icon buttons

toolpalette: call set_has_window

printunixdialog: Remove GtkDrawingArea::draw handler

the source file has been updated to use gtk_drawing_area_set_draw_func,
but the draw_cb handler in the ui file is still left.

stylecontext: Remove a bunch of unneeded headers